package com.runvp.common.util;

import com.alibaba.fastjson.JSONObject;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.BeanUtils;
import org.springframework.util.CollectionUtils;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.text.NumberFormat;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

/**
 * @ClassName: MoneyUtils
 * @description: 金钱计算
 * @author: kangkang.xu
 * @date: Created in 17:29 2019/5/10
 * @Version: 1.0
 **/
public class MoneyUtils {


    /**
     * todo 转换比 10 目前暂定转换比未 1 ，看后续需求是否调整为10倍
     */
    private static final Integer TEN = 1;
    /**
     * 100
     */
    private static final Integer ONE_HUNDRED = 100;
    /**
     * 1000
     */
    private static final Integer THOUSAND = 1000;
    /**
     * 两位小数
     */
    private static final Integer TEO = 2;


    public static void main(String[] args) {
        System.out.println(feeBackHandleTOBigDecimal(1L));
        System.out.println(feeHandleTOLong(new BigDecimal(1.5)));



    }

    /**
     * 对象 分转元
     * @param s 源对象
     * @param tClass 目标对象类型
     * @param attrArr 需要转换的属性列表 逗号分割，如a,b,c
     * @return T
     */
    public static <S,T> T modelAttrCent2Yuan(S s,Class<T> tClass,String attrArr){
        JSONObject source = JSONObject.parseObject(JSONObject.toJSONString(s));
        JSONObject target = new JSONObject();
        if(StringUtils.isNotBlank(attrArr)){
            String [] attr = attrArr.split(",");
            for(String str:attr){
                target.put(str,feeBackHandleTOBigDecimal(source.getLong(str)));
                source.remove(str);
            }
        }
        target.putAll(source);
        return JSONObject.parseObject(JSONObject.toJSONString(target),tClass);
    }
    /**
     * 浮点转Long 乘以100- 元 to 分
     *
     * @param fee
     * @return Long
     */
    public static int feeHandleTOInt(BigDecimal fee) {
        if (null == fee) {
            return 0;
        }
        fee = fee.setScale(TEO, RoundingMode.HALF_UP);
        return fee.multiply(new BigDecimal(ONE_HUNDRED)).intValue();
    }
    /**
     * 对象 list 分转元
     * @param ss 源对象集合
     * @param tClass 目标对象类型
     * @param attrArr 需要转换的属性列表 逗号分割，如a,b,c
     * @return Llist
     */
    public static <S,T> List<T> modelAttrCent2Yuan(List<S> ss,Class<T> tClass,String attrArr) {
        List<T> ts = new ArrayList<>();
        if(CollectionUtils.isEmpty(ss)){
            return ts;
        }
        for(S s:ss){
            ts.add(modelAttrCent2Yuan(s,tClass,attrArr));
        }
        return ts;
    }
    /**
     * 对象 元转分
     * @param s 源对象
     * @param tClass 目标对象类型
     * @param attrArr 需要转换的属性列表 逗号分割，如a,b,c
     * @return T
     */
    public static <S,T> T modelAttrYuan2Cent(S s,Class<T> tClass,String attrArr){
        JSONObject source = JSONObject.parseObject(JSONObject.toJSONString(s));
        JSONObject target = new JSONObject();
        if(StringUtils.isNotBlank(attrArr)){
            String [] attr = attrArr.split(",");
            for(String str:attr){
                target.put(str,feeHandleTOLong(source.getBigDecimal(str)));
                source.remove(str);
            }
        }
        target.putAll(source);
        return JSONObject.parseObject(JSONObject.toJSONString(target),tClass);
    }
    /**
     * 对象list 元转分
     * @param ss 源对象集合
     * @param tClass 目标对象类型
     * @param attrArr 需要转换的属性列表 逗号分割，如a,b,c
     * @return list
     */
    public static <S,T> List<T> modelAttrYuan2Cent(List<S> ss, Class<T> tClass, String attrArr){
        List<T> ts = new ArrayList<>();
        if(CollectionUtils.isEmpty(ss)){
            return ts;
        }
        for(S s:ss){
            ts.add(modelAttrYuan2Cent(s,tClass,attrArr));
        }
        return ts;
    }
    /**
     * Long转浮点，并除以100  - 分 to 元
     *
     * @return Long
     */
    public static BigDecimal feeBackHandleTOBigDecimal(Long fee) {
        if (null == fee) {
            return BigDecimal.ZERO;
        }
        return BigDecimalUtil.div(BigDecimal.valueOf(fee), BigDecimal.valueOf(ONE_HUNDRED)).setScale(TEO, RoundingMode.HALF_UP);
    }

    /**
     * 浮点转Long 乘以100- 元 to 分
     *
     * @param fee
     * @return Long
     */
    public static Long feeHandleTOLong(BigDecimal fee) {
        if (null == fee) {
            return 0L;
        }
        fee = fee.setScale(TEO, RoundingMode.HALF_UP);
        return fee.multiply(new BigDecimal(ONE_HUNDRED)).longValue();
    }

    public static BigDecimal strToBigDecimal(String str) {
        if(StringUtils.isBlank(str)){
            return BigDecimal.ZERO;
        }
        //构造以字符串内容为值的BigDecimal类型的变量bd
        BigDecimal bd = new BigDecimal(str);
        //设置小数位数，第一个变量是小数位数，第二个变量是取舍方法(四舍五入)
        bd = bd.setScale(2, BigDecimal.ROUND_HALF_UP);
        return bd;
    }

    public static String BigDecimalToStr(BigDecimal bg){
        if(null == bg){
            return "";
        }
        return bg.toString();
    }
    /**
     * 浮点转 int 乘以100
     *
     * @param fee
     * @return int
     */
    public static int pointTOInt(BigDecimal fee) {
        if (null == fee) {
            return 0;
        }
        fee = fee.setScale(TEO, RoundingMode.HALF_UP);
        return fee.multiply(new BigDecimal(ONE_HUNDRED)).intValue();
    }

    /**
     * int 转浮点  除以 100
     *
     * @param point
     * @return int
     */
    public static BigDecimal pointTOBigDecimal(Integer point) {
        if (null == point) {
            return BigDecimal.ZERO;
        }
        return BigDecimalUtil.div(BigDecimal.valueOf(point), BigDecimal.valueOf(ONE_HUNDRED)).setScale(TEO, RoundingMode.HALF_UP);
    }

    /**
     * 提供精确的加法运算。
     *
     * @param v1 被加数
     * @param v2 加数
     * @return 两个参数的和
     */

    private static double add(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.add(b2).doubleValue();
    }

    /**
     * 提供精确的减法运算。
     *
     * @param v1 被减数
     * @param v2 减数
     * @return 两个参数的差
     */

    private static double sub(double v1, double v2) {
        BigDecimal b1 = new BigDecimal(Double.toString(v1));
        BigDecimal b2 = new BigDecimal(Double.toString(v2));
        return b1.subtract(b2).doubleValue();
    }


    /**
     * 浮点类型保留两位小数，四舍五入
     *
     * @param data
     * @return String
     */
    private static String doubleToDecimal(double data) {
        NumberFormat nf = NumberFormat.getNumberInstance();
        // 保留两位小数
        nf.setMaximumFractionDigits(2);
        // 如果不需要四舍五入，可以使用RoundingMode.DOWN
        nf.setRoundingMode(RoundingMode.UP);
        return nf.format(data);
    }


    /**
     * BigDecimal to Integer 乘以100
     *
     * @param fee
     * @return Long
     */
    private static Integer feeHandleTOInteger(BigDecimal fee) {
        if (null == fee) {
            return 0;
        }
        fee = fee.setScale(TEO, RoundingMode.HALF_UP);
        return fee.multiply(new BigDecimal(ONE_HUNDRED)).intValue();
    }

    /**
     * long to  BigDecimal
     *
     * @param fee
     * @return BigDecimal
     */
    private static BigDecimal longTOBigDecimal(Long fee) {
        if (null == fee) {
            return BigDecimal.ZERO;
        }
        return BigDecimal.valueOf(fee);
    }

    /**
     * Integer转浮点，并除以100
     *
     * @return Integer
     */
    private static BigDecimal feeBackHandleIntegerTOBigDecimal(Integer fee) {
        if (null == fee) {
            return BigDecimal.ZERO;
        }
        return BigDecimalUtil.div(BigDecimal.valueOf(fee), BigDecimal.valueOf(ONE_HUNDRED));
    }


}
